home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Portable Patmos 1.1 / patmos-src / src / tcpglue.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-01-19  |  10.3 KB  |  517 lines  |  [TEXT/R*ch]
  1. /*
  2.  * BSD-style socket emulation library for the Mac
  3.  * Original author: Tom Milligan
  4.  * Current author: Charlie Reiman - creiman@ncsa.uiuc.edu
  5.  *
  6.  * This source file is placed in the public domian.
  7.  * Any resemblance to NCSA Telnet, living or dead, is purely coincidental.
  8.  *
  9.  *      National Center for Supercomputing Applications
  10.  *      152 Computing Applications Building
  11.  *      605 E. Springfield Ave.
  12.  *      Champaign, IL  61820
  13.  */
  14.  
  15. /*
  16.  *    Glue routines to call the MacTCP drivers
  17.  */
  18.  
  19. #ifdef USEDUMP
  20. # pragma load "socket.dump"
  21.  
  22. #else
  23. # include <Memory.h>
  24. # include <Files.h>
  25. # include <Errors.h>
  26.  
  27. # include <s_types.h>
  28. # include <neti_in.h>
  29.  
  30. # include "sock_str.h"
  31.  
  32. # include "sock_int.h"
  33.  
  34. #endif
  35.  
  36. #include <Devices.h>
  37.  
  38. static short driver = 0;
  39.  
  40. /*
  41.  * Hack fix for MacTCP 1.0.X bug
  42.  */
  43.  
  44. pascal char *ReturnA5(void) = {0x2E8D};
  45.  
  46. OSErr xOpenDriver() 
  47. { 
  48.     if (driver == 0) 
  49.     { 
  50.         ParamBlockRec pb; 
  51.         OSErr io; 
  52.         
  53.         pb.ioParam.ioCompletion = 0L; 
  54.         pb.ioParam.ioNamePtr = "\p.IPP"; 
  55.         pb.ioParam.ioPermssn = fsCurPerm; 
  56.         io = PBOpenSync(&pb); 
  57.         if (io != noErr) 
  58.             return(io); 
  59.         driver = pb.ioParam.ioRefNum; 
  60.     }
  61.     return noErr;
  62. }
  63.  
  64.  
  65. /*
  66.  * create a TCP stream
  67.  */
  68. OSErr xTCPCreate(
  69.     int buflen,
  70.     TCPNotifyProc notify,
  71.     TCPiopb *pb)
  72. {    
  73.     pb->ioCRefNum = driver;
  74.     pb->csCode = TCPCreate;
  75.     pb->csParam.create.rcvBuff = (char *)NewPtr(buflen);
  76.     pb->csParam.create.rcvBuffLen = buflen;
  77.     pb->csParam.create.notifyProc = notify;
  78.     return (xPBControlSync(pb));
  79. }
  80.  
  81. /*
  82.  * start listening for a TCP connection
  83.  */
  84. OSErr xTCPPassiveOpen( 
  85.     TCPiopb *pb, 
  86.     short port,
  87.     TCPIOCompletionProc completion)
  88. {
  89.     if (driver == 0)
  90.         return(invalidStreamPtr);
  91.  
  92.     pb->ioCRefNum = driver;
  93.     pb->csCode = TCPPassiveOpen;
  94.     pb->csParam.open.validityFlags = timeoutValue | timeoutAction;
  95.     pb->csParam.open.ulpTimeoutValue = 255 /* seconds */;
  96.     pb->csParam.open.ulpTimeoutAction = 0 /* 1:abort 0:report */;
  97.     pb->csParam.open.commandTimeoutValue = 0 /* infinity */;
  98.     pb->csParam.open.remoteHost = 0;
  99.     pb->csParam.open.remotePort = 0;
  100.     pb->csParam.open.localHost = 0;
  101.     pb->csParam.open.localPort = port;
  102.     pb->csParam.open.dontFrag = 0;
  103.     pb->csParam.open.timeToLive = 0;
  104.     pb->csParam.open.security = 0;
  105.     pb->csParam.open.optionCnt = 0;
  106.     return (xPBControl(pb,completion));
  107. }
  108.  
  109. /*
  110.  * connect to a remote TCP
  111.  */
  112. OSErr xTCPActiveOpen( 
  113.     TCPiopb *pb, 
  114.     short port,
  115.     long rhost,
  116.     short rport,
  117.     TCPIOCompletionProc completion)
  118. {
  119.     if (driver == 0)
  120.         return(invalidStreamPtr);
  121.  
  122.     pb->ioCRefNum = driver;
  123.     pb->csCode = TCPActiveOpen;
  124.     pb->csParam.open.validityFlags = timeoutValue | timeoutAction;
  125.     pb->csParam.open.ulpTimeoutValue = 60 /* seconds */;
  126.     pb->csParam.open.ulpTimeoutAction = 1 /* 1:abort 0:report */;
  127.     pb->csParam.open.commandTimeoutValue = 0;
  128.     pb->csParam.open.remoteHost = rhost;
  129.     pb->csParam.open.remotePort = rport;
  130.     pb->csParam.open.localHost = 0;
  131.     pb->csParam.open.localPort = port;
  132.     pb->csParam.open.dontFrag = 0;
  133.     pb->csParam.open.timeToLive = 0;
  134.     pb->csParam.open.security = 0;
  135.     pb->csParam.open.optionCnt = 0;
  136.     return (xPBControl(pb,completion));
  137. }
  138.  
  139. OSErr xTCPNoCopyRcv( 
  140.     TCPiopb *pb,
  141.     rdsEntry *rds, 
  142.     int rdslen,
  143.     int    timeout,
  144.     TCPIOCompletionProc completion)
  145. {
  146.     
  147.     if (driver == 0)
  148.         return(invalidStreamPtr);
  149.     
  150.     pb->ioCRefNum = driver;
  151.     pb->csCode = TCPNoCopyRcv;
  152.     pb->csParam.receive.commandTimeoutValue = timeout; /* seconds, 0 = blocking */
  153.     pb->csParam.receive.rdsPtr = (Ptr)rds;
  154.     pb->csParam.receive.rdsLength = rdslen;
  155.     return (xPBControl(pb,completion));
  156. }
  157.  
  158. OSErr xTCPBufReturn(TCPiopb *pb,rdsEntry *rds,TCPIOCompletionProc completion)
  159.     {
  160.     pb->ioCRefNum = driver;
  161.     pb->csCode = TCPRcvBfrReturn;
  162.     pb->csParam.receive.rdsPtr = (Ptr)rds;
  163.     
  164.     return (xPBControl(pb,completion));
  165.     }
  166.     
  167. /*
  168.  * send data
  169.  */
  170. OSErr xTCPSend( 
  171.     TCPiopb *pb,
  172.     wdsEntry *wds, 
  173.     Boolean push,
  174.     Boolean urgent,
  175.     TCPIOCompletionProc completion)
  176. {
  177.     if (driver == 0)
  178.         return invalidStreamPtr;
  179.     
  180.     pb->ioCRefNum = driver;
  181.     pb->csCode = TCPSend;
  182.     pb->csParam.send.validityFlags = timeoutValue | timeoutAction;
  183.     pb->csParam.send.ulpTimeoutValue = 60 /* seconds */;
  184.     pb->csParam.send.ulpTimeoutAction = 0 /* 0:abort 1:report */;
  185.     pb->csParam.send.pushFlag = push;
  186.     pb->csParam.send.urgentFlag = urgent;
  187.     pb->csParam.send.wdsPtr = (Ptr)wds;
  188.     return (xPBControl(pb,completion));
  189. }
  190.  
  191.  
  192. /*
  193.  * close a connection
  194.  */
  195. OSErr xTCPClose(TCPiopb *pb,TCPIOCompletionProc completion) 
  196. {
  197.     if (driver == 0)
  198.         return(invalidStreamPtr);
  199.     
  200.     pb->ioCRefNum = driver;
  201.     pb->csCode = TCPClose;
  202.     pb->csParam.close.validityFlags = timeoutValue | timeoutAction;
  203.     pb->csParam.close.ulpTimeoutValue = 60 /* seconds */;
  204.     pb->csParam.close.ulpTimeoutAction = 1 /* 1:abort 0:report */;
  205.     return (xPBControl(pb,completion));
  206. }
  207.  
  208. /*
  209.  * abort a connection
  210.  */
  211. OSErr xTCPAbort(TCPiopb *pb) 
  212. {
  213.     if (driver == 0)
  214.         return(invalidStreamPtr);
  215.     
  216.     pb->ioCRefNum = driver;
  217.     pb->csCode = TCPAbort;
  218.     return (xPBControlSync(pb));
  219. }
  220.  
  221. /*
  222.  * close down a TCP stream (aborting a connection, if necessary)
  223.  */
  224. OSErr xTCPRelease( 
  225.     TCPiopb *pb)
  226. {
  227.     OSErr io;
  228.     
  229.     if (driver == 0)
  230.         return(invalidStreamPtr);
  231.     
  232.     pb->ioCRefNum = driver;
  233.     pb->csCode = TCPRelease;
  234.     io = xPBControlSync(pb);
  235.     if (io == noErr)
  236.         DisposPtr(pb->csParam.create.rcvBuff); /* there is no release pb */
  237.     return(io);
  238. }
  239.  
  240. int
  241. xTCPBytesUnread(SocketPtr sp) 
  242. {
  243.     TCPiopb    *pb;
  244.     OSErr io;
  245.     
  246.     if (!(pb = sock_fetch_pb(sp)))
  247.         return -1;        /* panic */
  248.     
  249.     if (driver == 0)
  250.         return(-1);
  251.     
  252.     pb->ioCRefNum = driver;
  253.     pb->csCode = TCPStatus;
  254.     io = xPBControlSync(pb);
  255.     if (io != noErr)
  256.         return(-1);
  257.     return(pb->csParam.status.amtUnreadData);
  258. }
  259.  
  260. int
  261. xTCPBytesWriteable(SocketPtr sp)
  262.     {
  263.     TCPiopb *pb;
  264.     OSErr    io;
  265.     long    amount;
  266.     
  267.     if (!(pb = sock_fetch_pb(sp)))
  268.         return -1;        /* panic */
  269.     
  270.     if (driver == 0)
  271.         return(-1);
  272.     
  273.     pb->ioCRefNum = driver;
  274.     pb->csCode = TCPStatus;
  275.     io = xPBControlSync(pb);
  276.     if (io != noErr)
  277.         return(-1);
  278.     amount = pb->csParam.status.sendWindow-pb->csParam.status.amtUnackedData;
  279.     if (amount < 0)
  280.         amount = 0;
  281.     return amount;
  282.     }
  283.     
  284. int xTCPWriteBytesLeft(SocketPtr sp)
  285.     {
  286.     TCPiopb *pb;
  287.     OSErr    io;
  288.     
  289.     if (!(pb = sock_fetch_pb(sp)))
  290.         return -1;        /* panic */
  291.     
  292.     if (driver == 0)
  293.         return(-1);
  294.     
  295.     pb->ioCRefNum = driver;
  296.     pb->csCode = TCPStatus;
  297.     io = xPBControlSync(pb);
  298.     if (io != noErr)
  299.         return(-1);
  300.     return (pb->csParam.status.amtUnackedData);
  301.     }
  302.  
  303. int xTCPState(TCPiopb *pb)
  304.     {
  305.     OSErr io;
  306.     
  307.     if (driver == 0)
  308.         return(-1);
  309.     
  310.     pb->ioCRefNum = driver;
  311.     pb->csCode = TCPStatus;
  312.     io = xPBControlSync(pb);
  313.     if (io != noErr)
  314.         return(-1);
  315.     return(pb->csParam.status.connectionState);
  316.     }
  317.  
  318.  
  319. /*
  320.  * create a UDP stream, hook it to a socket.
  321.  */
  322. OSErr xUDPCreate(SocketPtr sp,int buflen,ip_port port)
  323.     {    
  324.     UDPiopb *pb;
  325.     OSErr   io;
  326.     
  327.     if ( !(pb = sock_fetch_pb(sp) ) )
  328.         return -1;
  329.     
  330.     pb->ioCRefNum = driver;
  331.     pb->csCode = UDPCreate;
  332.     pb->csParam.create.rcvBuff = (char *)NewPtr(buflen);
  333.     pb->csParam.create.rcvBuffLen = buflen;
  334.     pb->csParam.create.notifyProc = NULL;
  335.     pb->csParam.create.localPort = port;
  336.     if ( (io = xPBControlSync( (TCPiopb *)pb ) ) != noErr)
  337.         return io;
  338.         
  339.     sp->stream = pb->udpStream;
  340.     sp->sa.sin_port = pb->csParam.create.localPort;
  341.     return noErr;
  342.     }
  343.  
  344. /*
  345.  * ask for incoming data
  346.  */
  347. OSErr xUDPRead(SocketPtr sp,UDPIOCompletionProc completion) 
  348.     {
  349.     UDPiopb *pb;
  350.     
  351.     if ( !(pb = sock_fetch_pb(sp) ))
  352.         return -1;
  353.     
  354.     if (driver == 0)
  355.         return(invalidStreamPtr);
  356.     
  357.     pb->ioCRefNum = driver;
  358.     pb->csCode = UDPRead;
  359.     pb->csParam.receive.timeOut = 0 /* infinity */;
  360.     pb->csParam.receive.secondTimeStamp = 0/* must be zero */;
  361.     return (xPBControl ( (TCPiopb *)pb, (TCPIOCompletionProc)completion ));
  362.     }
  363.  
  364. OSErr xUDPBfrReturn(SocketPtr sp) 
  365.     {
  366.     UDPiopb *pb;
  367.  
  368.     if ( !(pb = sock_fetch_pb(sp) ))
  369.         return -1;
  370.  
  371.     if (driver == 0)
  372.         return(invalidStreamPtr);
  373.     
  374.     pb->ioCRefNum = driver;
  375.     pb->csCode = UDPBfrReturn;
  376.     pb->csParam.receive.rcvBuff = sp->recvBuf;
  377.     sp->recvBuf = 0;
  378.     sp->recvd   = 0;
  379.     return ( xPBControl( (TCPiopb *)pb,(TCPIOCompletionProc)-1 ) );
  380.     }
  381.  
  382. /*
  383.  * send data
  384.  */
  385. OSErr xUDPWrite(SocketPtr sp,ip_addr host,ip_port port,miniwds *wds,
  386.         UDPIOCompletionProc completion) 
  387.     {
  388.     UDPiopb    *pb;
  389.     
  390.     if ( !(pb = sock_fetch_pb(sp) ))
  391.         return -1;
  392.         
  393.     if (driver == 0)
  394.         return(invalidStreamPtr);
  395.     
  396.     pb->ioCRefNum = driver;
  397.     pb->csCode = UDPWrite;
  398.     pb->csParam.send.remoteHost = host;
  399.     pb->csParam.send.remotePort = port;
  400.     pb->csParam.send.wdsPtr = (Ptr)wds;
  401.     pb->csParam.send.checkSum = true;
  402.     pb->csParam.send.sendLength = 0/* must be zero */;
  403.     return (xPBControl( (TCPiopb *)pb, (TCPIOCompletionProc)completion));
  404.     }
  405.  
  406. /*
  407.  * close down a UDP stream (aborting a read, if necessary)
  408.  */
  409. OSErr xUDPRelease(SocketPtr sp) {
  410.     UDPiopb *pb;
  411.     OSErr io;
  412.  
  413.     if ( !(pb = sock_fetch_pb(sp) ))
  414.         return -1;
  415.     
  416.     if (driver == 0)
  417.         return(invalidStreamPtr);
  418.     
  419.     pb->ioCRefNum = driver;
  420.     pb->csCode = UDPRelease;
  421.     io = xPBControlSync( (TCPiopb *)pb );
  422.     if (io == noErr) {
  423.         DisposPtr(pb->csParam.create.rcvBuff);
  424.         }
  425.     return(io);
  426.     }
  427.  
  428. ip_addr xIPAddr(void) 
  429. {
  430.     struct IPParamBlock pbr;
  431.     OSErr io;
  432.     
  433.     pbr.ioCRefNum = driver;
  434.     pbr.csCode = ipctlGetAddr;
  435.     io = xPBControlSync( (TCPiopb *)&pbr );
  436.     if (io != noErr)
  437.         return(0);
  438.     return(pbr.ourAddress);
  439. }
  440.  
  441. long xNetMask() 
  442. {
  443.     struct IPParamBlock pbr;
  444.     OSErr io;
  445.     
  446.     pbr.ioCRefNum = driver;
  447.     pbr.csCode = ipctlGetAddr;
  448.     io = xPBControlSync( (TCPiopb *)&pbr);
  449.     if (io != noErr)
  450.         return(0);
  451.     return(pbr.ourNetMask);
  452. }
  453.  
  454. unsigned short xMaxMTU()
  455. {
  456.     struct UDPiopb pbr;
  457.     OSErr io;
  458.     
  459.     pbr.ioCRefNum = driver;
  460.     pbr.csCode = UDPMaxMTUSize;
  461.     pbr.csParam.mtu.remoteHost = xIPAddr();
  462.     io = xPBControlSync( (TCPiopb *)&pbr );
  463.     if (io != noErr)
  464.         return(0);
  465.     return(pbr.csParam.mtu.mtuSize);
  466. }
  467.  
  468. OSErr xPBControlSync(TCPiopb *pb) 
  469. { 
  470.     (pb)->ioCompletion = 0L; 
  471.     return PBControlSync((ParmBlkPtr)(pb)); 
  472. }
  473.  
  474. #pragma segment SOCK_RESIDENT
  475.  
  476. OSErr xTCPRcv( 
  477.     TCPiopb *pb,
  478.     Ptr buf, 
  479.     int buflen,
  480.     int    timeout,
  481.     TCPIOCompletionProc completion)
  482. {
  483.     
  484.     if (driver == 0)
  485.         return(invalidStreamPtr);
  486.     
  487.     pb->ioCRefNum = driver;
  488.     pb->csCode = TCPRcv;
  489.     pb->csParam.receive.commandTimeoutValue = timeout; /* seconds, 0 = blocking */
  490.     pb->csParam.receive.rcvBuff = buf;
  491.     pb->csParam.receive.rcvBuffLen = buflen;
  492.     return (xPBControl(pb,completion));
  493. }
  494.  
  495.  
  496. OSErr xPBControl(TCPiopb *pb,TCPIOCompletionProc completion) 
  497. { 
  498.     pb->ioNamePtr = ReturnA5();
  499.     
  500.     if (completion == 0L) 
  501.     { 
  502.         (pb)->ioCompletion = 0L; 
  503.         return(PBControlSync((ParmBlkPtr)(pb)));        /* sync */
  504.     } 
  505.     else if (completion == (TCPIOCompletionProc)-1L) 
  506.     { 
  507.         (pb)->ioCompletion = 0L; 
  508.         return(PBControlAsync((ParmBlkPtr)(pb)));        /* async */
  509.     } 
  510.     else 
  511.     {  
  512.         (pb)->ioCompletion = completion; 
  513.         return(PBControlAsync((ParmBlkPtr)(pb)));        /* async */
  514.     } 
  515. }
  516.  
  517.